JavaScript lygiagreti aibė: gijoms saugios aibės operacijos

JavaScript, tradiciškai žinoma kaip vienos gijos kalba, vis dažniau naudojama aplinkose, kuriose lygiagretumas yra būtinas. Nors JavaScript naršyklėje kodą daugiausia vykdo vienoje gijoje, Web Workers ir Node.js darbinės gijos leidžia vykdyti kodą lygiagrečiai. Tai reikalauja kurti duomenų struktūras, kurios yra saugios lygiagrečiai prieigai. Viena iš tokių duomenų struktūrų yra lygiagreti aibė (Concurrent Set) – standartinės aibės variantas, užtikrinantis gijų saugumą operacijų metu.

Lygiagretumo supratimas JavaScript kalboje

Prieš gilinantis į lygiagrečias aibes, trumpai apžvelkime lygiagretumą JavaScript kalboje.

• Vienos gijos modelis: Pagrindinis JavaScript vykdymo modelis naršyklėse yra vienos gijos. Tai reiškia, kad vienu metu gali būti vykdoma tik viena kodo dalis.
• Asinchroninės operacijos: Norint vienu metu tvarkyti kelias užduotis, JavaScript labai priklauso nuo asinchroninių operacijų, naudojant atgalinio iškvietimo funkcijas (callbacks), pažadus (Promises) ir async/await. Šios technikos nesukuria tikro lygiagretumo, bet neleidžia užblokuoti pagrindinės gijos.
• Web Workers: Web Workers leidžia vykdyti tikrą lygiagretų apdorojimą, paleidžiant JavaScript kodą foninėse gijose. Tai ypač svarbu skaičiavimams imlioms užduotims, kurios kitu atveju užšaldytų vartotojo sąsają. Pavyzdžiui, vaizdų apdorojimas ar sudėtingi skaičiavimai gali būti perkelti į Web Worker.
• Node.js darbinės gijos: Node.js suteikia panašų mechanizmą su darbinėmis gijomis, leidžiančiomis išnaudoti kelių branduolių procesorius geresniam serverio našumui. Tai ypač naudinga tvarkant daugybę vienu metu gaunamų užklausų.

Kai kelios gijos pasiekia ir keičia bendrus duomenis, gali kilti lenktynių sąlygos (race conditions). Lenktynių sąlyga atsiranda, kai operacijos rezultatas priklauso nuo nenuspėjamos gijų vykdymo tvarkos. Tai gali sukelti duomenų sugadinimą ir netikėtą elgseną. Todėl gijoms saugios duomenų struktūros yra būtinos valdant bendrus duomenis lygiagrečiose aplinkose.

Kas yra lygiagreti aibė?

Lygiagreti aibė yra aibės (Set) duomenų struktūra, kuri užtikrina gijoms saugias operacijas. Tai reiškia, kad kelios gijos gali vienu metu pridėti, šalinti ar tikrinti elementų buvimą aibėje, nesukeldamos duomenų sugadinimo ar lenktynių sąlygų. Pagrindinė lygiagrečios aibės idėja yra suteikti mechanizmus, skirtus sinchronizuoti prieigą prie pagrindinės duomenų saugyklos.

Pagrindinės lygiagrečios aibės savybės:

• Saugumas gijoms: Užtikrina, kad operacijos yra atominės ir nuoseklios, net kai jas vienu metu vykdo kelios gijos.
• Atomiškumas: Užtikrina, kad kiekviena operacija (pvz., pridėti, šalinti, patikrinti) yra atliekama kaip viena, nedaloma visuma.
• Nuoseklumas: Išlaiko duomenų struktūros vientisumą, apsaugodama nuo duomenų sugadinimo.
• Be užraktų arba pagrįsta užraktais: Gali būti įgyvendinta naudojant algoritmus be užraktų (kurie yra sudėtingesni, bet potencialiai našesni) arba su aiškiais užraktais (kuriuos lengviau įgyvendinti, bet gali kilti konkurencija).

Lygiagrečios aibės įgyvendinimas JavaScript

Lygiagrečios aibės įgyvendinimas JavaScript kalboje reikalauja panaudoti funkcijas, kurios leidžia naudoti bendrą atmintį ir atomines operacijas. Pagrindiniai įrankiai tam yra SharedArrayBuffer ir Atomics.

1. SharedArrayBuffer

SharedArrayBuffer yra JavaScript objektas, kuris leidžia keliems Web Workers arba Node.js darbinėms gijoms pasiekti tą pačią atminties sritį. Jis suteikia būdą dalintis duomenimis tarp gijų, o tai yra būtina kuriant lygiagrečias duomenų struktūras.

Pavyzdys:

            // Create a SharedArrayBuffer with a size of 1024 bytes
const sharedBuffer = new SharedArrayBuffer(1024);

            

              
                Copy
              
            
          

2. Atomics

Atomics objektas suteikia atomines operacijas, kurios gali būti naudojamos atlikti gijoms saugias operacijas su duomenimis, saugomais SharedArrayBuffer. Atominės operacijos garantuotai yra nedalomos, taip išvengiant lenktynių sąlygų. Atomics objektas suteikia metodus, skirtus atomiškai skaityti, rašyti ir modifikuoti reikšmes SharedArrayBuffer.

Pavyzdys:

            // Create a Uint32Array view on the SharedArrayBuffer
const atomicArray = new Uint32Array(sharedBuffer);

// Atomically add 1 to the value at index 0
Atomics.add(atomicArray, 0, 1);

            

              
                Copy
              
            
          

Konceptualus lygiagrečios aibės įgyvendinimas

Štai konceptualus planas, kaip galėtumėte įgyvendinti lygiagrečią aibę JavaScript, naudojant SharedArrayBuffer ir Atomics. Atkreipkite dėmesį, kad gamybai paruoštas įgyvendinimas reikalautų žymiai daugiau sudėtingumo, kad būtų galima tvarkyti kolizijas, keisti dydį ir efektyviai valdyti atmintį.

1. Pagrindinė saugykla: Naudokite SharedArrayBuffer aibės elementams saugoti. Kadangi JavaScript tiesiogiai nepalaiko savavališkų objektų saugojimo tipizuotame masyve, jums reikės mechanizmo objektams serializuoti/deserializuoti į/iš baitų reprezentacijos. Įprasta technika yra naudoti sveikųjų skaičių masyvą kaip indeksus į atskirą objektų saugyklą.
2. Atominės operacijos: Naudokite Atomics operacijas, kad atliktumėte gijoms saugias operacijas su pagrindine saugykla. Pavyzdžiui, galite naudoti Atomics.compareExchange, kad atomiškai pridėtumėte ar pašalintumėte elementus iš aibės.
3. Kolizijų tvarkymas: Įgyvendinkite kolizijų sprendimo strategiją (pvz., atskiro grandinimo (separate chaining) arba atviro adresavimo (open addressing)), kad išspręstumėte atvejus, kai keli elementai atitinka tą patį indeksą saugykloje.
4. Dydžio keitimas: Įgyvendinkite dydžio keitimo mechanizmą, kad prireikus dinamiškai padidintumėte aibės talpą.

Supaprastintas pavyzdys (tik iliustracinis – neparuoštas gamybai)

Šis pavyzdys pateikia supaprastintą iliustraciją. Jame praleidžiamos svarbios detalės, tokios kaip atminties valdymas, kolizijų sprendimas ir tinkamas serializavimas. Nenaudokite šio kodo tiesiogiai gamybinėje aplinkoje.

            class ConcurrentSet {
  constructor(size) {
    this.buffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * size);
    this.data = new Int32Array(this.buffer);
    this.size = size;
    this.length = 0; //Atomic.add not used in this simplistic implementation
  }

  has(value) {
    for (let i = 0; i < this.length; i++) {
      if (Atomics.load(this.data,i) === value) {
        return true;
      }
    }
    return false;
  }

  add(value) {
    if (!this.has(value) && this.length < this.size) {
      Atomics.store(this.data, this.length, value);
      this.length++;
      return true;
    }
    return false; // Or resize if needed (complex)
  }
  remove(value) {
    // Simplified remove (not truly atomic without locks or compareExchange)
    for (let i = 0; i < this.length; i++) {
      if (Atomics.load(this.data, i) === value) {
        //Replace with last element (order not guaranteed)
        Atomics.store(this.data, i, Atomics.load(this.data,this.length -1));
        this.length--;
        return true;
      }
    }
     return false;
  }
}

            

              
                Copy
              
            
          

Paaiškinimas:

• Klasė ConcurrentSet naudoja SharedArrayBuffer elementams saugoti.
• Metodas has iteruoja per masyvą, kad patikrintų, ar elementas egzistuoja.
• Metodas add prideda elementą į masyvą, jei jo dar nėra ir jei yra laisvos vietos.
• remove pakeičia elementą paskutiniu masyvo elementu ir sumažina 'ilgis'.

Svarbūs aspektai:

• Serializavimas: Šiame supaprastintame pavyzdyje tiesiogiai naudojami sveikieji skaičiai. Sudėtingesniems objektams reikės įdiegti serializavimo/deserializavimo mechanizmą, kad objektai būtų konvertuojami į ir iš baitų reprezentacijos, kurią galima saugoti SharedArrayBuffer.
• Kolizijų sprendimas: Šis pavyzdys nesprendžia kolizijų. Realiame įgyvendinime jums reikės kolizijų sprendimo strategijos.
• Dydžio keitimas: Šis pavyzdys nesprendžia SharedArrayBuffer dydžio keitimo. SharedArrayBuffer dydžio keitimas yra sudėtingas ir reikalauja sukurti naują buferį bei nukopijuoti duomenis.
• Užrakinimas/Sinchronizavimas: Nors Atomics suteikia atomines operacijas, sudėtingesnėms operacijoms gali prireikti aiškių užrakinimo mechanizmų (pvz., naudojant muteksą, įgyvendintą su Atomics), kad būtų užtikrintas gijų saugumas. Paprastas pašalinimas aukščiau turi lenktynių sąlygas.

Lygiagrečių aibių naudojimo atvejai

Lygiagrečios aibės yra naudingos įvairiuose scenarijuose, kai kelios gijos turi vienu metu pasiekti ir keisti duomenų aibę. Keletas dažniausių naudojimo atvejų:

• Lygiagretus duomenų apdorojimas: Apdorojant didelius duomenų rinkinius lygiagrečiai naudojant Web Workers ar Node.js darbinės gijas, lygiagreti aibė gali būti naudojama tarpiniams rezultatams saugoti arba sekti, kurie elementai jau buvo apdoroti. Pavyzdžiui, paskirstytoje vaizdų apdorojimo sistemoje lygiagreti aibė galėtų sekti, kurias vaizdo dalis apdorojo skirtingi darbininkai.
• Spartinančioji atmintinė (Caching): Daugiasrautėje serverio aplinkoje lygiagreti aibė gali būti naudojama gijoms saugiai spartinančiajai atmintinei įgyvendinti. Kelios gijos gali vienu metu pridėti, šalinti ar tikrinti spartinančiosios atmintinės elementų buvimą, nesukeldamos lenktynių sąlygų.
• Dublikatų šalinimas: Apdorojant duomenų srautą iš kelių šaltinių, lygiagreti aibė gali būti naudojama efektyviam duomenų dublikatų šalinimui. Kelios gijos gali vienu metu pridėti elementus į aibę, užtikrindamos, kad būtų apdorojami tik unikalūs elementai.
• Bendradarbiavimas realiuoju laiku: Realaus laiko bendradarbiavimo programose lygiagreti aibė gali būti naudojama sekti, kurie vartotojai šiuo metu yra prisijungę arba kurie dokumentai yra redaguojami. Pavyzdžiui, bendradarbiavimo teksto redaktorius galėtų naudoti lygiagrečią aibę valdyti vartotojus, kurie šiuo metu redaguoja dokumentą.

Alternatyvos lygiagrečioms aibėms

Nors lygiagrečios aibės tam tikruose scenarijuose gali būti naudingos, yra ir kitų alternatyvų, kurias galite apsvarstyti, priklausomai nuo jūsų konkrečių poreikių:

• Nekeičiamos duomenų struktūros: Nekeičiamos duomenų struktūros yra tokios, kurių negalima keisti po jų sukūrimo. Tai pašalina lenktynių sąlygų galimybę, nes jokia gija negali keisti duomenų struktūros vietoje. Bibliotekos, tokios kaip Immutable.js, suteikia nekintamas duomenų struktūras JavaScript. Tačiau nekintamos duomenų struktūros paprastai reikalauja sukurti naujas duomenų kopijas modifikuojant, o tai gali turėti įtakos našumui.
• Pranešimų perdavimas: Užuot tiesiogiai dalijęsi duomenimis tarp gijų, galite naudoti pranešimų perdavimą duomenims komunikuoti. Šis metodas leidžia išvengti bendros atminties ir atominių operacijų poreikio. Web Workers ir Node.js darbinės gijos suteikia integruotus pranešimų perdavimo mechanizmus.
• Užrakinimo mechanizmai: Galite naudoti aiškius užrakinimo mechanizmus (pvz., muteksus), kad sinchronizuotumėte prieigą prie bendrų duomenų. Tačiau užrakinimas gali sukelti konkurenciją ir aklavietes, todėl jį reikėtų naudoti atsargiai. Užrakto įgyvendinimas naudojant Atomics operacijas reikalauja kruopštaus apsvarstymo, kad būtų išvengta aktyvaus laukimo (spinlock) ir užtikrintas sąžiningumas.

Našumo aspektai

Efektyvus lygiagrečios aibės įgyvendinimas reikalauja kruopštaus našumo įvertinimo. Kai kurie veiksniai, į kuriuos reikia atsižvelgti:

• Konkurencija: Didelė konkurencija gali kilti, kai kelios gijos nuolat bando pasiekti tuos pačius duomenis. Tai gali lemti našumo sumažėjimą dėl dažno užraktų įgijimo ir atleidimo. Konkurencijos minimizavimas yra labai svarbus siekiant gero našumo.
• Atominės operacijos: Atominės operacijos gali būti santykinai brangios, palyginti su ne atominėmis operacijomis. Todėl svarbu sumažinti atliekamų atominių operacijų skaičių.
• Atminties valdymas: Efektyvus atminties valdymas yra labai svarbus siekiant išvengti atminties nutekėjimų ir fragmentacijos.
• Duomenų lokalumas: Prieiga prie duomenų, kurie yra saugomi greta atmintyje, paprastai yra greitesnė nei prieiga prie duomenų, išsklaidytų po visą atmintį. Todėl projektuojant lygiagrečią aibę svarbu atsižvelgti į duomenų lokalumą.

Gerosios praktikos naudojant lygiagrečias aibes

Štai keletas gerųjų praktikų, kurių reikėtų laikytis naudojant lygiagrečias aibes JavaScript:

• Minimizuokite bendrą būseną: Stenkitės kuo labiau sumažinti bendros būsenos kiekį tarp gijų. Kuo mažiau bendros būsenos turite, tuo mažiau jums reikia sinchronizavimo mechanizmų.
• Protingai naudokite atomines operacijas: Naudokite atomines operacijas tik tada, kai tai būtina. Venkite naudoti atomines operacijas toms operacijoms, kurias galima atlikti be sinchronizavimo.
• Apsvarstykite nekeičiamas duomenų struktūras: Jei įmanoma, apsvarstykite galimybę naudoti nekeičiamas duomenų struktūras vietoj keičiamų. Nekeičiamos duomenų struktūros pašalina lenktynių sąlygų galimybę.
• Kruopščiai testuokite: Kruopščiai testuokite savo kodą, kad įsitikintumėte, jog jis yra saugus gijoms ir neturi lenktynių sąlygų. Naudokite įrankius, tokius kaip gijų sanitizatoriai, kad aptiktumėte galimas problemas.
• Profiluokite savo kodą: Profiluokite savo kodą, kad nustatytumėte našumo kliūtis. Naudokite profiliavimo įrankius, kad įvertintumėte savo lygiagrečios aibės našumą ir nustatytumėte tobulinimo sritis.

Išvada

Lygiagrečios aibės yra vertingas įrankis valdant bendrus duomenis lygiagrečiose JavaScript aplinkose. Nors lygiagrečios aibės įgyvendinimas reikalauja kruopštaus gijų saugumo, atomiškumo ir našumo apsvarstymo, lygiagretaus vykdymo teikiama nauda gali būti didelė. Naudodami SharedArrayBuffer ir Atomics galite sukurti gijoms saugias duomenų struktūras, kurios leis jums visapusiškai išnaudoti kelių branduolių procesorius ir pagerinti jūsų JavaScript programų našumą. Nepamirškite atsižvelgti į kompromisus tarp skirtingų lygiagretumo modelių ir pasirinkti metodą, kuris geriausiai atitinka jūsų konkrečius poreikius.

JavaScript toliau tobulėjant ir randant kelią į vis daugiau lygiagrečių aplinkų, gijoms saugių duomenų struktūrų, tokių kaip lygiagrečios aibės, svarba tik didės. Suprasdami šiame straipsnyje aptartus principus ir technikas, būsite gerai pasirengę kurti tvirtas ir keičiamo dydžio lygiagrečias JavaScript programas.

Reikėtų nenuvertinti sudėtingumo, susijusio su teisingu SharedArrayBuffer ir Atomics naudojimu. Prieš bandant kurti sudėtingas daugiagijes duomenų struktūras, užtikrinkite tvirtą lygiagretumo modelių ir galimų spąstų, tokių kaip aklavietės (deadlocks), gyvosios aklavietės (livelocks) ir atminties konkurencija, supratimą. Bibliotekos, specializuojančios lygiagrečiose duomenų struktūrose, gali pasiūlyti iš anksto sukurtus, gerai išbandytus sprendimus, sumažinančius subtilių klaidų įvedimo riziką.